package org.jeecg.modules.coursearrangeatom.controller;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.ibatis.annotations.Param;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.mybatis.TenantContext;
import org.jeecg.modules.classes.entity.CouClass;
import org.jeecg.modules.classes.service.ICouClassService;
import org.jeecg.modules.common.api.ISysInfo;
import org.jeecg.modules.common.baseentity.BaseApiEntity;
import org.jeecg.modules.coucoursearrange.entity.CouCourseArrange;
import org.jeecg.modules.coucoursearrange.service.ICouCourseArrangeService;
import org.jeecg.modules.coursearrangeatom.entity.CouCourseArrangeAtom;
import org.jeecg.modules.coursearrangeatom.service.ICouCourseArrangeAtomService;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;

import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.modules.coursearrangeatom.vo.CouCourseArrangeAtomAllProVo;
import org.jeecg.modules.coursearrangeatom.vo.CouCourseArrangeAtomVo;
import org.jeecg.modules.coursearrangeatom.vo.CouCourseArrangeOneTableVo;
import org.jeecg.modules.coursearrangeatom.vo.ViewCouCourseArrAtomVo;
import org.jeecg.modules.student.vo.StuStudentVo;
import org.jeecg.modules.teacher.entity.TeaTeacher;
import org.jeecg.modules.teacher.service.ITeaTeacherService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;

 /**
 * @Description: cou_course_arrange_atom
 * @author: baochangrong
 * @Date:   2022-02-23
 * @Version: V1.0
 */
@Api(tags="cou_course_arrange_atom")
@RestController
@RequestMapping("/coursearrangeatom/couCourseArrangeAtom")
@Slf4j
public class CouCourseArrangeAtomController extends JeecgController<CouCourseArrangeAtom, ICouCourseArrangeAtomService> {
	@Autowired
	private ICouCourseArrangeAtomService couCourseArrangeAtomService;
	@Autowired
	ISysBaseAPI sysBaseAPI;
	 @Autowired
	 private ISysInfo sysInfo;
	@Autowired
	private ICouCourseArrangeService couCourseArrangeService;
	 @Autowired
	 private ITeaTeacherService teaTeacherService;
	 @Autowired
	 private ICouClassService couClassService;

	/**
	 * 分页列表查询
	 *
	 * @param couCourseArrangeAtom
	 * @param pageNo
	 * @param pageSize
	 * @param req
	 * @return
	 */
	@AutoLog(value = "cou_course_arrange_atom-分页列表查询")
	@ApiOperation(value="cou_course_arrange_atom-分页列表查询", notes="cou_course_arrange_atom-分页列表查询")
	@GetMapping(value = "/list")
	public Result<?> queryPageList(CouCourseArrangeAtom couCourseArrangeAtom,
								   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
								   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
								   HttpServletRequest req) {
		QueryWrapper<CouCourseArrangeAtom> queryWrapper = QueryGenerator.initQueryWrapper(couCourseArrangeAtom, req.getParameterMap());
		Page<CouCourseArrangeAtom> page = new Page<CouCourseArrangeAtom>(pageNo, pageSize);
		IPage<CouCourseArrangeAtom> pageList = couCourseArrangeAtomService.page(page, queryWrapper);
		return Result.OK(pageList);
	}

	 @AutoLog(value = "cou_course_arrange_atom-课表科目数据查询")
	 @ApiOperation(value="cou_course_arrange_atom-课表科目数据查询", notes="cou_course_arrange_atom-课表科目数据查询")
	 @GetMapping(value = "/getCourseDataList")
	 public Result<?> getCourseDataList(CouCourseArrangeAtom couCourseArrangeAtom,
									HttpServletRequest req) {
		 String courseArrangeId = couCourseArrangeAtom.getCourseArrangeId();
		 String targetObjId = couCourseArrangeAtom.getTargetObjId();
		 Integer relObjTtype = couCourseArrangeAtom.getRelObjTtype();
		 String selectTeacherIds =  ""; //等待传入选中老师ids参数，待补充（此处参数为可选参数）
		 List<CouCourseArrangeAtom> couCourseArrangeList = couCourseArrangeAtomService.getCourseDataList(courseArrangeId,targetObjId,relObjTtype,selectTeacherIds);
		 return Result.OK(couCourseArrangeList);
	 }


	 @AutoLog(value = "getCourseDetailsByTeacher-冲突检测页 教师个人课表")
	 @ApiOperation(value="getCourseDetailsByTeacher-冲突检测页 教师个人课表", notes="getCourseDetailsByTeacher-冲突检测页 教师个人课表")
	 @GetMapping(value = "/getArrangeAtomByObjId")
	 public Result<?> getArrangeAtomByObjId(CouCourseArrangeAtomVo couCourseArrangeAtomVo,int checkContradiction,
											HttpServletRequest req) {
		//参数relObjId，relObjTtype，courseArrangeId， targetObjId，schoolYearId， semesterId
//		querySysInfo(req,couCourseArrangeAtomVo);

		 //组装vo以外的其他参数
		 Map<String,String> queryParam = sysInfo.getMapQueryParamByReq(req);
		 //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值克隆给vo
		 BaseApiEntity baseApiEntity = sysInfo.querySysInfoCloneObj(req,couCourseArrangeAtomVo,false); //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值给vo
		 TeaTeacher teacher = teaTeacherService.getTeacherByUserId( baseApiEntity.getLoginUser().getId() );
		 // 如果必要的查询参数都为空，则默认查询当前登录老师的课表（适用于移动端）
		 if(oConvertUtils.isNotEmpty(teacher) && oConvertUtils.isEmpty(couCourseArrangeAtomVo.getTeacherId() )
		 	&& oConvertUtils.isEmpty(couCourseArrangeAtomVo.getCourseArrangeId() )
			&& oConvertUtils.isEmpty(couCourseArrangeAtomVo.getClassId() )
			&& oConvertUtils.isEmpty(couCourseArrangeAtomVo.getSubjectId() )
				 && oConvertUtils.isEmpty(couCourseArrangeAtomVo.getClassroomId() )
		 ){
		 	couCourseArrangeAtomVo.setTeacherId(teacher.getId());
		 } ;
		 //根据用户身份重新设置查询条件值，不同的用户身份查询过滤不同的数据：
		 //1.获取用户身份 userIdentity loginUser.getUserIdentity() 用户身份字典码user_identity， 3教师 4学生 5家长 6班级  1普通用户 2上级部门负责人
		 //2.获取用户id loginUser.getId()
		 //userIdentity 用户身份字典码user_identity， 3教师 4学生 5家长 6班级  1普通用户 2上级部门负责人
//		 couCourseArrangeAtomVo = reSetObjectValue(baseApiEntity, couCourseArrangeAtomVo);
		List<CouCourseArrangeAtomVo> couCourseArrangeAtomVos = couCourseArrangeAtomService.getArrangeAtomByObjId(couCourseArrangeAtomVo,checkContradiction);
		return Result.OK(couCourseArrangeAtomVos);
	 }


	/**
	 *   添加
	 * @param couCourseArrangeAtom
	 * @return
	 */
	@AutoLog(value = "cou_course_arrange_atom-添加")
	@ApiOperation(value="cou_course_arrange_atom-添加", notes="cou_course_arrange_atom-添加")
	@PostMapping(value = "/add")
	public Result<?> add(@RequestBody CouCourseArrangeAtom couCourseArrangeAtom) {
		couCourseArrangeAtomService.save(couCourseArrangeAtom);
		return Result.OK("添加成功！");
	}

	/**
	 *  编辑
	 *
	 * @param couCourseArrangeAtom
	 * @return
	 */
	@AutoLog(value = "cou_course_arrange_atom-编辑")
	@ApiOperation(value="cou_course_arrange_atom-编辑", notes="cou_course_arrange_atom-编辑")
	@PutMapping(value = "/edit")
	public Result<?> edit(@RequestBody CouCourseArrangeAtom couCourseArrangeAtom) {
		couCourseArrangeAtomService.updateById(couCourseArrangeAtom);
		return Result.OK("编辑成功!");
	}

	/**
	 *   通过id删除
	 *
	 * @param id
	 * @return
	 */
	@AutoLog(value = "cou_course_arrange_atom-通过id删除")
	@ApiOperation(value="cou_course_arrange_atom-通过id删除", notes="cou_course_arrange_atom-通过id删除")
	@DeleteMapping(value = "/delete")
	public Result<?> delete(@RequestParam(name="id",required=true) String id) {
		couCourseArrangeAtomService.removeById(id);
		return Result.OK("删除成功!");
	}

	/**
	 *  批量删除
	 *
	 * @param ids
	 * @return
	 */
	@AutoLog(value = "cou_course_arrange_atom-批量删除")
	@ApiOperation(value="cou_course_arrange_atom-批量删除", notes="cou_course_arrange_atom-批量删除")
	@DeleteMapping(value = "/deleteBatch")
	public Result<?> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
		this.couCourseArrangeAtomService.removeByIds(Arrays.asList(ids.split(",")));
		return Result.OK("批量删除成功!");
	}

	/**
	 * 通过id查询
	 *
	 * @param id
	 * @return
	 */
	@AutoLog(value = "cou_course_arrange_atom-通过id查询")
	@ApiOperation(value="cou_course_arrange_atom-通过id查询", notes="cou_course_arrange_atom-通过id查询")
	@GetMapping(value = "/queryById")
	public Result<?> queryById(@RequestParam(name="id",required=true) String id) {
		CouCourseArrangeAtom couCourseArrangeAtom = couCourseArrangeAtomService.getById(id);
		if(couCourseArrangeAtom==null) {
			return Result.error("未找到对应数据");
		}
		return Result.OK(couCourseArrangeAtom);
	}

    /**
    * 导出excel
    *
    * @param request
    * @param couCourseArrangeAtom
    */
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, CouCourseArrangeAtom couCourseArrangeAtom) {
        return super.exportXls(request, couCourseArrangeAtom, CouCourseArrangeAtom.class, "cou_course_arrange_atom");
    }

    /**
      * 通过excel导入数据
    *
    * @param request
    * @param response
    * @return
    */
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, CouCourseArrangeAtom.class);
    }





	 /**
	  * 通过视图 ===
	  * 课表详情查询 listByCourseArrangeId
	  */
	 @AutoLog(value = "cou_course_arrange_atom-通过视图-课表详情查询")
	 @ApiOperation(value="cou_course_arrange_atom-通过视图-课表详情查询", notes="cou_course_arrange_atom-通过视图-课表详情查询")
	 @GetMapping(value = "/listByCourseArrangeId")
	 public Result<?> listByCourseArrangeId(ViewCouCourseArrAtomVo viewCouCourseArrAtomVo,
											HttpServletRequest req) {
		 //组装vo以外的其他参数
		 Map<String,String> queryParam = sysInfo.getMapQueryParamByReq(req);
		 //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值给vo
		 BaseApiEntity baseApiEntity = sysInfo.querySysInfoCloneObj(req,viewCouCourseArrAtomVo,false); //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值给vo

		 //根据用户身份重新设置查询条件值，不同的用户身份查询过滤不同的数据：
		 //1.获取用户身份 userIdentity loginUser.getUserIdentity() 用户身份字典码user_identity， 3教师 4学生 5家长 6班级  1普通用户 2上级部门负责人
		 //2.获取用户id loginUser.getId()
		 //userIdentity 用户身份字典码user_identity， 3教师 4学生 5家长 6班级  1普通用户 2上级部门负责人
//		 viewCouCourseArrAtomVo = reSetObjectValue(baseApiEntity, viewCouCourseArrAtomVo); //需要的话需要重写该方法

//		 String tenantId = req.getHeader("tenant-id");
//		 String viewIndexNumArr = JSONObject.toJSONString(viewIndexNum).replace("[","").replace("]","");
//		 String viewIndexNumArr = viewIndexNum.replace("\",\"",",").replace("[\"","").replace("\"]","");
		 //如果排除项目有空格或者中文的逗号，可以替换处理
		 if(oConvertUtils.isNotEmpty(viewCouCourseArrAtomVo.getCourArraAtomSectionHidden()) ){
		 	viewCouCourseArrAtomVo.setCourArraAtomSectionHidden(viewCouCourseArrAtomVo.getCourArraAtomSectionHidden().replace(" ","").replace("，",","));
		 }
		 List<ViewCouCourseArrAtomVo> itemList = couCourseArrangeAtomService.listByCourseArrangeId(viewCouCourseArrAtomVo,queryParam);
		 return Result.OK(itemList);
	 }

//	 /**
//	  * 从request获取 token 用户信息，组织信息
//	  *
//	  * @param req
//	  * @return
//	  */
//	 public BaseApiEntity querySysInfo(HttpServletRequest req, Object achAchievementSubjProjItemDemo) {
//
//		 BaseApiEntity baseApiEntity = new BaseApiEntity();
//
//		 //获取当前登录用户信息
//		 String token = req.getHeader(CommonConstant.X_ACCESS_TOKEN);
//		 String username = JwtUtil.getUsername(token);
//		 baseApiEntity.setUsername(username);
//		 baseApiEntity.setCreateBy(username);
//		 baseApiEntity.setUpdateBy(username);
//
//		 LoginUser loginUser = sysBaseAPI.getUserByName(username); //.getUserById() 获取登录用户
//		 baseApiEntity.setLoginUser(loginUser);
//		 String sysOrgCode = loginUser.getOrgCode();//获取当前用户的当前的部门编码（不是id是编码）,该编码随前端切换
//		 String tenantId = req.getHeader("tenant-id");//获取当前登录用户的租户id
//		 String schoolYearId = req.getHeader("school-year-id");//获取当前登录系统选择的学年
//		 String semesterId = req.getHeader("semester-id");//获取当前登录系统选择的学期
//		 baseApiEntity.setTenantId(tenantId);
//		 baseApiEntity.setSchoolYearId(schoolYearId);
//		 baseApiEntity.setSemesterId(semesterId);
//		 String departId = sysBaseAPI.getDepartIdsByOrgCode(sysOrgCode);//获取当前用户设置的部门id
//		 List<String> subDepIdsList = sysBaseAPI.getSubDepIdsByDepId(departId); //获取下级部门的部门id，自定义改造sysBaseAPI
//		 baseApiEntity.setSysOrgCode(sysOrgCode);
//		 baseApiEntity.setSubDepIdsList(subDepIdsList);
//		 String subDepSysOrgCodes = sysBaseAPI.getSubDepOrgCodesByDepId(departId); //直接获取下级部门的orgcode，自定义改造sysBaseAPI
//		 baseApiEntity.setSubDepSysOrgCodes(subDepSysOrgCodes);
//		 //userIdentity 用户身份字典码user_identity， 3教师 4学生 1普通用户 2上级部门负责人 5家长 6班级
//		 int userIdentity = loginUser.getUserIdentity();//获取当前登录用户身份：字典码 user_identity
//		 baseApiEntity.setUserIdentity(userIdentity);
//		 //给业务对象赋 创建人、修改人、部门编码的值
//		 BeanUtils.copyProperties(baseApiEntity,achAchievementSubjProjItemDemo);
//
//		 return baseApiEntity;
//	 }


	 /**
	  * 调换课程
	  * adjustmentArrangeAtomUpdate
	  * @return
	  */
	 @AutoLog(value = "cou_course_arrange_atom-调换课程")
	 @ApiOperation(value="cou_course_arrange_atom-调换课程", notes="cou_course_arrange_atom-调换课程")
	 @PutMapping(value = "/adjustmentArrangeAtomUpdate")
	 public Result<?> adjustmentArrangeAtomUpdate(@RequestBody JSONObject jsonObject) {
	 	 JSONObject JSONObjArrangeAtom1 = jsonObject.getJSONObject("couCourseArrangeAtomOne");
		 JSONObject JSONObjArrangeAtom2 = jsonObject.getJSONObject("couCourseArrangeAtomTwo");
	 	//调换之前，先判断课表状态（课表状态：(1初始 2预排课 3已排课 4已发布 5已下线 6需重排)）
		 CouCourseArrange arrangeObj1 = couCourseArrangeService.getById(JSONObjArrangeAtom1.getString("courseArrangeId"));
		 //CourseArrangeStatus = 当4已发布 5已下线,不可调换
		 if ("4".equals(arrangeObj1.getCourseArrangeStatus())|| "5".equals(arrangeObj1.getCourseArrangeStatus())){
		 	return Result.OK("“已发布或已下线”的课表，不可调换");
		 }
		 CouCourseArrange arrangeObj2 = couCourseArrangeService.getById(JSONObjArrangeAtom2.getString("courseArrangeId"));
		 if ("4".equals(arrangeObj2.getCourseArrangeStatus())|| "5".equals(arrangeObj2.getCourseArrangeStatus())){
			 return Result.OK("“已发布或已下线”的课表，不可调换");
		 }
		 if (JSONObjArrangeAtom1.getString("courseArrangeId").indexOf(",") >= 0 || JSONObjArrangeAtom1.getString("courseArrangeStatus").indexOf(",") >= 0 ){
			 return Result.OK("选择课表过多，请选择一个课表操作");
		 }
		 if (JSONObjArrangeAtom2.getString("courseArrangeId").indexOf(",") >= 0 || JSONObjArrangeAtom2.getString("courseArrangeStatus").indexOf(",") >= 0){
			 return Result.OK("选择课表过多，请选择一个课表操作");
		 }

		 JSONArray atomType = JSONObjArrangeAtom1.getJSONArray("atomType");//取出调换项
		 for (Object typeIndexObj : atomType) { //['4,3,2']
			 int typeIndex = Integer.parseInt(typeIndexObj.toString());
			 CouCourseArrangeAtom couCourseArrangeAtom1 = new CouCourseArrangeAtom();
			 CouCourseArrangeAtom couCourseArrangeAtom2 = new CouCourseArrangeAtom();
			 switch (typeIndex) {
			 	//case（1:调换班级 2:调换教室 3:调换老师 4:调换科目 5:调换学生），当typeIndex包含7说明‘单双周’标识也要调换
				 case 1:
					 break;
				 case 2:
				 	 //根据类型，调换第一个的数据（教室）
					 couCourseArrangeAtom1.setId(JSONObjArrangeAtom1.getString("ccaaClassroomId"));
					 couCourseArrangeAtom1.setCourseArrangeId(JSONObjArrangeAtom1.getString("courseArrangeId"));
					 couCourseArrangeAtom1.setRelObjId(JSONObjArrangeAtom2.getString("classroomId"));
					 couCourseArrangeAtom1.setRelObjTtype(typeIndex);
					 //调换第一个的数据（教室）
					 couCourseArrangeAtom2.setId(JSONObjArrangeAtom2.getString("ccaaClassroomId"));
					 couCourseArrangeAtom2.setCourseArrangeId(JSONObjArrangeAtom2.getString("courseArrangeId"));
					 couCourseArrangeAtom2.setRelObjId(JSONObjArrangeAtom1.getString("classroomId"));
					 couCourseArrangeAtom2.setRelObjTtype(typeIndex);
					 break;
				 case 3:
					 //根据类型，调换第一个的数据（科目）
					 couCourseArrangeAtom1.setId(JSONObjArrangeAtom1.getString("ccaaTeacherId"));
					 couCourseArrangeAtom1.setCourseArrangeId(JSONObjArrangeAtom1.getString("courseArrangeId"));
					 couCourseArrangeAtom1.setRelObjId(JSONObjArrangeAtom2.getString("teacherId"));
					 couCourseArrangeAtom1.setRelObjTtype(typeIndex);
					 //调换第一个的数据（科目）
					 couCourseArrangeAtom2.setId(JSONObjArrangeAtom2.getString("ccaaTeacherId"));
					 couCourseArrangeAtom2.setCourseArrangeId(JSONObjArrangeAtom2.getString("courseArrangeId"));
					 couCourseArrangeAtom2.setRelObjId(JSONObjArrangeAtom1.getString("teacherId"));
					 couCourseArrangeAtom2.setRelObjTtype(typeIndex);
					 break;
				 case 4:
					 //根据类型，调换第一个的数据（科目）
					 couCourseArrangeAtom1.setId(JSONObjArrangeAtom1.getString("ccaaSubjectId"));
					 couCourseArrangeAtom1.setCourseArrangeId(JSONObjArrangeAtom1.getString("courseArrangeId"));
					 couCourseArrangeAtom1.setRelObjId(JSONObjArrangeAtom2.getString("subjectId"));
					 couCourseArrangeAtom1.setRelObjTtype(typeIndex);
					 //调换第一个的数据（科目）
					 couCourseArrangeAtom2.setId(JSONObjArrangeAtom2.getString("ccaaSubjectId"));
					 couCourseArrangeAtom2.setCourseArrangeId(JSONObjArrangeAtom2.getString("courseArrangeId"));
					 couCourseArrangeAtom2.setRelObjId(JSONObjArrangeAtom1.getString("subjectId"));
					 couCourseArrangeAtom2.setRelObjTtype(typeIndex);
					 break;
				 case 5:
					 break;
				 default:
					 break;
			 }
			 // 调换单双周，typeIndex=包含7说明
			 // 当typeIndex包含7说明‘单双周’标识要调换 ,//['4,3,2,7']
			 for (Object _aIndex : atomType) {
				int _index = Integer.parseInt(_aIndex.toString());
			 	if (_index == 7){
					couCourseArrangeAtom1.setCourArraAtomIzSingle(Integer.parseInt(JSONObjArrangeAtom2.getString("courArraAtomIzSingle")));
					couCourseArrangeAtom2.setCourArraAtomIzSingle(Integer.parseInt(JSONObjArrangeAtom1.getString("courArraAtomIzSingle")));
				}
			 }
			 couCourseArrangeAtomService.updateById(couCourseArrangeAtom1);
			 couCourseArrangeAtomService.updateById(couCourseArrangeAtom2);
			 couCourseArrangeAtom1 = null;
			 couCourseArrangeAtom2 = null;
		 }

		 return Result.OK("调换成功!");
	 }


	 /**
	  * 编辑课程（选中一节，新数据填充或修改已有数据）
	  * adjustmentArrangeAtomPut
	  *
	  * @return
	  */
	 @AutoLog(value = "cou_course_arrange_atom-编辑课程")
	 @ApiOperation(value="cou_course_arrange_atom-编辑课程", notes="cou_course_arrange_atom-编辑课程")
	 @PutMapping(value = "/adjustmentArrangeAtomPut")
	 public Result<?> adjustmentArrangeAtomPut(@RequestBody JSONObject jsonObject) {
		 JSONObject JSONObjArrangeAtom1 = jsonObject.getJSONObject("adjustmentCoursePutData");
		 JSONObject JSONObjArrangeAtom2 = jsonObject.getJSONObject("adjustmentCoursePutParams");
		 //编辑之前，先判断课表状态（课表状态：(1初始 2预排课 3已排课 4已发布 5已下线 6需重排)）
		 CouCourseArrange arrangeObj1 = couCourseArrangeService.getById(JSONObjArrangeAtom1.getString("courseArrangeId"));
		 //CourseArrangeStatus = 当4已发布 5已下线,不可编辑
		 if ("4".equals(arrangeObj1.getCourseArrangeStatus())){
			 return Result.OK("已发布的课表，不可编辑");
		 }
		 else if ("5".equals(arrangeObj1.getCourseArrangeStatus())){
			 return Result.OK("已下线的课表，不可编辑");
		 }
		 else if (JSONObjArrangeAtom1.getString("courseArrangeId").indexOf(",") >= 0  || JSONObjArrangeAtom1.getString("courseArrangeStatus").indexOf(",") >= 0 ){
			 return Result.OK("选择课表过多，请选择一个课表操作");
		 }

		 JSONArray atomType = JSONObjArrangeAtom1.getJSONArray("atomType");//取出调换项
		 for (Object typeIndexObj : atomType) { //['4,3,2,7'] 包含7时编辑单双周
			 int typeIndex = Integer.parseInt(typeIndexObj.toString());
			 CouCourseArrangeAtom couCourseArrangeAtom1 = new CouCourseArrangeAtom();
			 switch (typeIndex) {
				 //case（1:编辑班级 2:编辑教室 3:编辑老师 4:编辑科目 5:编辑学生），当typeIndex包含7说明‘单双周’标识也要编辑
				 case 1:
					 break;
				 case 2:
					 //根据类型，编辑第一个的数据（教室）
					 couCourseArrangeAtom1.setId(JSONObjArrangeAtom1.getString("ccaaClassroomId"));
					 couCourseArrangeAtom1.setCourseArrangeId(JSONObjArrangeAtom1.getString("courseArrangeId"));
					 couCourseArrangeAtom1.setRelObjId(JSONObjArrangeAtom2.getString("classroomId"));
					 couCourseArrangeAtom1.setRelObjTtype(typeIndex);
					 break;
				 case 3:
					 //根据类型，编辑第一个的数据（科目）
					 couCourseArrangeAtom1.setId(JSONObjArrangeAtom1.getString("ccaaTeacherId"));
					 couCourseArrangeAtom1.setCourseArrangeId(JSONObjArrangeAtom1.getString("courseArrangeId"));
					 couCourseArrangeAtom1.setRelObjId(JSONObjArrangeAtom2.getString("teacherId"));
					 couCourseArrangeAtom1.setRelObjTtype(typeIndex);
					 break;
				 case 4:
					 //根据类型，编辑第一个的数据（科目）
					 couCourseArrangeAtom1.setId(JSONObjArrangeAtom1.getString("ccaaSubjectId"));
					 couCourseArrangeAtom1.setCourseArrangeId(JSONObjArrangeAtom1.getString("courseArrangeId"));
					 couCourseArrangeAtom1.setRelObjId(JSONObjArrangeAtom2.getString("subjectId"));
					 couCourseArrangeAtom1.setRelObjTtype(typeIndex);
					 break;
				 case 5:
					 break;
				 default:
					 break;
			 }
			 // 编辑单双周，typeIndex=包含7说明
			 // 当typeIndex包含7说明‘单双周’标识要编辑 ,//['4,3,2,7']
			 for (Object _aIndex : atomType) {
				 int _index = Integer.parseInt(_aIndex.toString());
				 if (_index == 7){
					 couCourseArrangeAtom1.setCourArraAtomIzSingle(Integer.parseInt(JSONObjArrangeAtom2.getString("courArraAtomIzSingle")));
				 }
			 }
			 couCourseArrangeAtomService.updateById(couCourseArrangeAtom1);
			 couCourseArrangeAtom1 = null;
		 }

		 return Result.OK("编辑成功!");
	 }
	 /* 全校全年级1张课表：查询同一时间上课的班级、老师、教室、科目,显示在1节课的位置
	  * 需求：查询全校同时在上体育课的班级数量，判断操场是否够用，查询同时在上语文课的老师找到最少课的时间开展教研活动或开学科会议
	  * 扩展需求：查询某教室同时使用的班级数量，查询某老师同时上课的班级数量
	  * 查询单科全校课表：查询全年级的语文课、查询全年级的体育课，得到1张课表
	  * 查询全校课表：查询全年级没课的班级、查询全年级在上体育课的班级，得到1张课表
	  *  */
	 @AutoLog(value = "CouCourseArrangeOneTable-全校课表一张表数据查询")
	 @ApiOperation(value="CouCourseArrangeOneTable-全校课表一张表数据查询", notes="CouCourseArrangeOneTable-全校课表一张表数据查询")
	 @GetMapping(value = "/queryCouArrangeAtomByObjectType")
	 public Result<?>  queryCouArrangeAtomByObjectType(CouCourseArrangeAtomAllProVo couCourseArrangeAtomAllPro,HttpServletRequest req){

		 //组装vo以外的其他参数
		 Map<String,String> queryParam = sysInfo.getMapQueryParamByReq(req);
		 //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值克隆给vo
		 BaseApiEntity baseApiEntity = sysInfo.querySysInfoCloneObj(req,couCourseArrangeAtomAllPro,false); //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值给vo
		 couCourseArrangeAtomAllPro.setSysOrgCode(null);//忽略部门,只按照班级的部门，上级部门查询下级部门数据
		 //ignorePropertyList 忽略属性
		 if(oConvertUtils.isNotEmpty(queryParam.get("ignorePropertyList"))){
			 if(queryParam.get("ignorePropertyList").indexOf("1") != -1 ){
				 couCourseArrangeAtomAllPro.setSchoolYearId(null); //忽略学年
			 }
			 if(queryParam.get("ignorePropertyList").indexOf("2") != -1 ){
				 couCourseArrangeAtomAllPro.setSemesterId(null);//忽略学期
			 }
			 if(queryParam.get("ignorePropertyList").indexOf("3") != -1 ){
				 couCourseArrangeAtomAllPro.setSysOrgCode(null);//忽略部门
				 couCourseArrangeAtomAllPro.setSubDepSysOrgCodes(null);
				 couCourseArrangeAtomAllPro.setSubDepIdsList(null);
			 }
			 if(queryParam.get("ignorePropertyList").indexOf("4") != -1 ){
				 couCourseArrangeAtomAllPro.setClassGradesessionYear(null);//忽略届级
			 }
		 }
		 // includePropertyList 包含属性：查询当前用户的课表（老师/学生/班级等）
		 if(oConvertUtils.isNotEmpty(queryParam.get("includePropertyList")) && queryParam.get("includePropertyList").indexOf("1") != -1 ){
			 reSetObjectValueByUsersClass(baseApiEntity,couCourseArrangeAtomAllPro);
		 }
		 //查老师自己的课表
		 if(oConvertUtils.isNotEmpty(queryParam.get("includePropertyList")) && queryParam.get("includePropertyList").indexOf("2") != -1 ){
		 	TeaTeacher teaTeacher = teaTeacherService.getTeacherByUserId(baseApiEntity.getLoginUser().getId());
			if(oConvertUtils.isNotEmpty(teaTeacher)){
				couCourseArrangeAtomAllPro.setTeacherId(teaTeacher.getId());
			}
		 }
		 //按照不同的身份查询数据：老师、查自己的课表，学生和班级查询自己的班级的课表(注意一个学生可能有多个班级)，家长查自己孩子班级的课表
		 List<CouCourseArrangeOneTableVo> itemList = couCourseArrangeAtomService.queryCouArrangeAtomByObjectType(couCourseArrangeAtomAllPro,queryParam);
		 return Result.OK(itemList);
	 }

	 /**
	  * 查询全校各班级课表：查询各个班级的课表，得到N个班级的N张课表
	  * @return
	  */

	 @AutoLog(value = "CouCourseArrangeAllPro-全校任意课表N张表数据查询")
	 @ApiOperation(value="CouCourseArrangeAllPro-全校任意课表N张表数据查询", notes="CouCourseArrangeAllPro-全校任意课表N张表数据查询")
	 @GetMapping(value = "/queryCouArrangeAtomByGradeIdsOrClassIds")
	 public Result<?>  queryCouArrangeAtomByGradeIdsOrClassIds(@Param("couCourseArrangeAtomAllPro") CouCourseArrangeAtomAllProVo couCourseArrangeAtomAllPro,HttpServletRequest req){


		 //组装vo以外的其他参数
		 Map<String,String> queryParam = sysInfo.getMapQueryParamByReq(req);
		 //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值克隆给vo
		 BaseApiEntity baseApiEntity = sysInfo.querySysInfoCloneObj(req,couCourseArrangeAtomAllPro,false); //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值给vo

		 return Result.OK(couCourseArrangeAtomService.queryCouArrangeAtomByGradeIdsOrClassIds(couCourseArrangeAtomAllPro,queryParam));
	 }


	 /**
	  *
	  * 有需要身份识别的业务需打开下方注释补充查询条件就可以了
	  * 根据业务需要设置查询参数，不同身份的用户不同的查询参数、得到不同的查询结果
	  * 注意：有些业务并不需要身份识别，有些业务必须识别身份:4学生用户只能查自己的数据不能查别人的，6班级用户只能查自己班级的数据不能查其他班级的数据，
	  * 3老师只能查老师所在部门和下级部门的数据，1普通用户（一般是非教学用户）
	  * @param baseApiEntity
	  * @return Object
	  */
	 private CouCourseArrangeAtomAllProVo reSetObjectValueByUsersClass(BaseApiEntity baseApiEntity, CouCourseArrangeAtomAllProVo couCourseArrangeAtomAllProVo){
		 //1.获取用户身份 userIdentity loginUser.getUserIdentity() 用户身份字典码user_identity， 3教师 4学生 5家长 6班级  1普通用户 2上级部门负责人
		 //2.获取用户id loginUser.getId()
		 int userIdentity = baseApiEntity.getUserIdentity();//获取当前登录用户身份：字典码 user_identity，3教师 4学生 5家长 6班级  1普通用户 2上级部门负责人
		 String userId = baseApiEntity.getLoginUser().getId(); //当前登录用户id

		 //有需要身份识别的业务需打开下方注释补充查询条件就可以了
		 //根据业务需要设置查询参数，不同身份的用户不同的查询参数、得到不同的查询结果
		 //注意：有些业务并不需要身份识别，有些业务必须识别身份:4学生用户只能查自己的数据不能查别人的，6班级用户只能查自己班级的数据不能查其他班级的数据，3老师只能查老师所在部门和下级部门的数据，1普通用户（一般是非教学用户） 2上级部门负责人只能查所在部门和下级部门的数据

		 //  //userIdentity 用户身份字典码user_identity， 3教师 4学生 5家长 6班级  1普通用户 2上级部门负责人
		 // // 学生、老师、班级、家长，都有绑定用户的user_id字段，可以根据user_id查询到对应的学生、老师、班级 基础档案信息
		 if (userIdentity ==4 || userIdentity ==3){
			 //学生身份只能查看自己班级的数据（注意学生可能有多个班级） //老师身份，可以查看当前部门和下级子集部门的数据（注意老师教学多个班级）
			 List<CouClass> couClassList = couClassService.getCouClassListByUser(baseApiEntity.getLoginUser(),baseApiEntity.getSchoolYearId(),baseApiEntity.getSemesterId());
			 String classIds="";
			 for(CouClass c:couClassList){
				 classIds = classIds+c.getId()+",";
			 }
			 if(classIds.length()>1){
			 	classIds = classIds.substring(0,classIds.length()-1);
			 }
			 couCourseArrangeAtomAllProVo.setClassId(classIds);
			 couCourseArrangeAtomAllProVo.setSysOrgCode(null);
			 couCourseArrangeAtomAllProVo.setSubDepSysOrgCodes(null);
			 //当前用户和业务数据可能不在同一个部门，需设置为null，例如：学生张三属于七年级部门，成绩数据在初中教学部
		 }
		 else if (userIdentity == 5 ){
			 //家长身份只能查看孩子的数据，注意一个家长可能有多个孩子 一个孩子属于多个家长
			 //家长身份只能查看孩子的数据
			 String classIds = userId; //获取家长的孩子的班级id

		 }
		 else if (userIdentity == 6 ){
			 //班级身份只能查看自己班级的数据
//			String classId = loginUser.getId();//获取班级id
			 CouClass couClass = couClassService.getCouClassByUserID(userId);
			 couCourseArrangeAtomAllProVo.setClassId(couClass.getId());
			 couCourseArrangeAtomAllProVo.setSysOrgCode(null); //当前用户和业务数据可能不在同一个部门，需设置为null，例如：某班级属于七年级部门，成绩数据在初中教学部
			 couCourseArrangeAtomAllProVo.setSubDepSysOrgCodes(null);
		 }
		 else if ( userIdentity == 1 || userIdentity == 2 ){
			 //普通用户身份、部门负责人（领导），可以查看当前部门和下级子集部门的数据
			 couCourseArrangeAtomAllProVo.setSysOrgCode(null);
			 couCourseArrangeAtomAllProVo.setSubDepSysOrgCodes(baseApiEntity.getSubDepSysOrgCodes());
		 }
		 else{
			 //其他身份或默认设置
			 couCourseArrangeAtomAllProVo.setSysOrgCode(null);
			 couCourseArrangeAtomAllProVo.setSubDepSysOrgCodes(baseApiEntity.getSubDepSysOrgCodes());
		 }
		 return couCourseArrangeAtomAllProVo;
	 }

 }
